arrayFuncs.moveDown - Code Metrics - Inspection of "reorganize & renaming files" - nightfury7/universalbasics.js - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( ad9a28...55041a )

by Night
created 2018-07-15 12:26 UTC
arrayFuncs.moveDown A

↳ Parent: src/ub.arrays.core.js
Complexity

Conditions	3
Paths	2
Size

Total Lines	16
Code Lines	8
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	3
eloc	8
nc	2
nop	1
dl	0
loc	16
rs	10
c	0
b	0
f	0
/** global: UB */
/** global: Buffer */

/*! ARRAY UTILS */

var arrayFuncs = {

	merge: function(){
		var arr = this;
		var val1 = arr[0];

		// if array of strings
		if (val1.isString()){
			return val1.join("");
		}

		// if array of arrays
		if (val1.isArray()){
			var merged = [];
			for (var a = 0, al = arr.length; a<al; a++){
				merged.addArray(arr[a]);
			}
			return merged;
		}

		// if array of Buffers
		//removeIf(nodejs)
		if (val1 instanceof Buffer){

			// calc the total length of all buffers
			var buffers = arr;
			var len = 0;
			for(var b = 0, bl = buffers.length; b < bl; b++) {
				len += buffers[b].length;
			}

			// create a new buffer of that length
			var mega = new Buffer(len);

			// write all buffers into the mega buffer
			var cur = 0;
			for(var b = 0, bl = buffers.length; b < bl; b++) {

				buffers[b].copy(mega, cur, 0);
				cur += buffers[b].length;
			}
			return mega;
		}
		//endRemoveIf(nodejs)

		return null;
	},
	
	indexOf: function(value){
		var list = this;
		if (list.length === 0) {
			return -1;
		}
		for (var a = 0, al = list.length;a<al;a++){
			if (list[a] == value){
				return a;
			}
		}
		return -1;
	},
	lastIndexOf: function(value){

		var list = this;
		if (list.length === 0) {
			return -1;
		}
		for (var a = list.length-1;a>=0;a--){
			if (list[a] == value){
				return a;
			}
		}
		return -1;
	},
	isEqual: function(list2){

		var list = this;
		if (list == null || list2 == null) {

			return list == list2;
		}	
		if(list.length != list2.length){
			return false;
		}
		
		var len = list.length;
		
		for (var i = 0;i<len;i++){
			if(list[i] !== list2[i]){
				return false;
			}
		}
		
		return true;
	},
	isNotEqual: function(list2){
		var list = this;
		return !IsEqual(list, list2);
	},

	exists: function(){
		var list = this;
		return list != null && list.length > 0;

	},
	isFirst: function(value){
		var list = this;
		return list != null && list[0] == value;

	},
	isLast: function(value){
		var list = this;
		return list != null && list[list.length - 1] == value;

	},
	count: function(value, not = false){

		var list = this;
		var total = 0;
		for (var a = 0, al = list.length;a<al;a++){
			if (not) {
				if (list[a] != value) {
					total++;
				}
			}else {
				if (list[a] == value) {
					total++;
				}
			}
		}
		return total;
	},
	or: function(list2){
		var list = this;
		if (Exists(list)) {
			return list;
		}
		return list2;
	},
	
	part: function(start, end){
		var list = this;
		
		// quickly exit if no items or no results possible
		if (list == null || list.length === 0 || start > end || start >= list.length) {

			return [];
		}
		
		// just get the part we need
		return list.slice(start, end + 1);
	},
	
	swap: function(slot1, slot2){
		var list = this;
		var temp = list[slot2];
		list[slot2] = list[slot1];
		list[slot1] = temp;
	},

	add: function(item){
		var list = this;
		list.push(item);
		return list.length - 1;
	},
	addToStart: function(item){
		var list = this;
		list.unshift(item);
		return 0;
	},
	/** return false if item exists, true if item does not */
	addOnce: function(value){
		var list = this;
		
		// return false if item exists
		if (list.indexOf(value) > -1) {
			return false;
		}
		
		// add if not found
		list.push(value);
		return true;
	},
	
	addArray: function(toAdd, addAtSlot = -1, modifyMain = true){
		var list = this;
		
		if (toAdd != null && toAdd.length > 0) {

			if (!modifyMain) {
				list = list.concat(); /// shallow clone
			}
			
			// set length first so allocates memory (maybe?)
			var origLen = list.length;
			if (addAtSlot === -1){
				list.length += toAdd.length;
			}
			
			// set all slots
			var next = addAtSlot === -1 ? origLen : addAtSlot;
			for (var a = 0, al = toAdd.length;a<al;a++, next++){
				list[next] = toAdd[a];
			}
		}
		return list;
	},
	
	/** adds the given value many times */
	addManyTimes: function(val, times){
		var list = this;
		
		if (times <= 0) {
			return list;
		}
		
		var n = list.length;
		for (var t = 0;t<times;t++){
			list[n++] = val;
		}
		
		return list;
	},
	
	addRange: function(toAdd, startSlot, endSlot){
		var list = this;
		
		// exit if no work
		if (endSlot < startSlot) {
			return;
		}
		
		// per wanted slot of the `add` array
		startSlot = startSlot.limitToArray(toAdd);
		endSlot = endSlot.limitToArray(toAdd);
		for (var s = startSlot;s <= endSlot;s++){
			
			// add into `main` array
			list.push(toAdd[s]);
			
		}
	},
	
	/** returns final index of added item, or index of already existing item */
	findOrAdd: function(value){
		var list = this;
		
		// return index of item if exists
		var i = list.indexOf(value);
		if (i > -1) {
			return i;
		}
		
		// add if not found
		i = list.length;
		list[i] = value;
		return i;
	},
	
	insertOne: function(item, slot){
		var list = this;
		
		// adds one slot at the given point
		// modifies the main array
		
		list.splice(slot, 0, item);
	},

	/** if slot = -1 or outside the array, the item is added to the END of the array.
	 * Otherwise the item is added at the given slot. */
	insertOneOrAdd: function(item, slot){
		var list = this;
		
		// adds one slot at the given point
		// modifies the main array
		
		if (slot < 0 || slot >= list.length) {
			list.push(item);
			return list.length - 1;
		}else {

			list.splice(slot, 0, item);
			return slot;
		}
	},
	insertArray: function(newItems, slot, returnNew = true){
		var list = this;
		
		// adds many slots at the given point
		// returns a new array
		if(returnNew){
			return list.slice(0, slot).concat(newItems).concat(list.slice(slot));
		}
		
		// adds many slots at the given point
		// modifies the main array
		for (var a = 0, al = newItems.length;a<al;a++){
			list.splice(slot++, 0, newItems[a]);
		}
		return list;
	},
	insertArrayAfter: function(newItems, after){
		var list = this;
		if (list.isLast(after)) {
			list.addArray(newItems);
		} else {
			var i = list.indexOf(after);
			list.insertArray(i + 1, newItems);
		}
	},
	

	removeAndInsert: function(from, to){
		var list = this;
		
		// ensure slots within array
		var al = list.length;
		from = from.limitTo(0, al - 1);
		to = to.limitTo(0, al - 1);
		if (to < from) {
			var i1 = to;
			var i2 = from;
		}else {
			var i1 = from;

			var i2 = to;

		}
		
		// fill unaffected header
		var result = [];
		if(i1 > 0){
			for (var a = 0;a<i1;a++){
				result[a] = list[a];
			}
		}
		
		// fill "to"
		result[to] = list[from];
		
		// fill between from and to
		if(to < from){
			for (a = to + 1; a <= from; a++) {
				result[a] = list[a - 1];
			}
		}else {
			for (a = from; a < to; a++) {
				result[a] = list[a + 1];
			}
		}
		
		// fill unaffected footer
		for (var a = i2 + 1;a<al;a++){

			result[a] = list[a];
		}
		
		return result;
	},
	
	/** replace a range of items with a given array */
	replaceRange: function(replaceStartSlot, replaceEndSlot, newItems, returnNew = true){
		var list = this;
		
		
		// simply remove a single item
		if (replaceStartSlot == replaceEndSlot && newItems.length === 0) {
			if (returnNew) {
				list = list.concat();
			}
			list.splice(replaceStartSlot, 1);
			return list;
			
		// simply replace a single item
		}else if (replaceStartSlot == replaceEndSlot && newItems.length === 1) {
			if (returnNew) {
				list = list.concat();
			}
			list[replaceStartSlot] = newItems[0];
			return list;
			
		}else{
			
			// alt method if returning a new array
			if(returnNew){
				return list.slice(0, replaceStartSlot).concat(newItems).concat(list.slice(replaceEndSlot + 1));
			}
			
			// remove many
			list.splice(replaceStartSlot, (replaceEndSlot - replaceStartSlot) + 1);
			
			// insert many
			var slot = replaceStartSlot;
			for (var a = 0, al = newItems.length;a<al;a++){
				list.splice(slot++, 0, newItems[a]);
			}
		}
		return list;
	},
	
	replace: function(find, replace, stringReplace = false){
		var list = this;
		for (var i = 0, il = list.length;i<il;i++){
			if (stringReplace){

				// replace substring within string items
				var str = list[i];
				if (str && str.constructor === String) {
					list[i] = str.replaceAll(find, replace);
				}
			}else{

				// replace entire items
				if (list[i] == find) {
					list[i] = replace;
				}
			}
		}
	},
	replaceOnce: function(find, replace){
		var list = this;
		for (var i = 0, il = list.length;i<il;i++){
			if (list[i] == find) {
				list[i] = replace;
				return;
			}
		}
	},
	replaceMany: function(findArray, replaceArray){
		var list = this;
		if (findArray.length != replaceArray.length){
			return;
		}
		for (var i = 0, il = list.length;i<il;i++){
			for (var f = 0, fl = findArray.length;f<fl;f++){
				var find = findArray[f];
				if (list[i] == find) {
					list[i] = replaceArray[f];
					break;
				}
			}
		}
	},
	
	
	remove: function(value, stringReplace = false){
		var list = this;
		for (var i = 0, il = list.length;i<il;i++){
			if (stringReplace){

				// remove substring within string items
				var str = list[i];
				if (str && str.constructor === String) {
					list[i] = str.removeAll(value);
				}
			}else{

				// remove entire items
				if (list[i] == value) {
					list.splice(i, 1);
					i--;

					il--;
				}
			}
		}
	},
	removeOnce: function(val){
		var list = this;
		var i = list.indexOf(val);
		if (i > -1) {
			list.splice(i, 1);
		}
		return i;
	},
	removeFirst: function(returnNew = false){
		var list = this;
		if (returnNew) {
			return list.slice(1);
		}else{

			if (list.length > 0) {
				list.splice(0, 1);
			}
			return list;
		}
	},
	removeFirstX: function(count, returnNew = false){
		var list = this;
		
		// if fewer items than wanted, clear entire array
		if (list.length < count) {
			if (returnNew) {
				return [];
			}
			list.length = 0;
			return list;
		}
		
		// delete X items from start
		if (returnNew) {
			return list.slice(count);
		}else{

			list.splice(0, count);
			return list;
		}
	},
	removeLast: function(returnNew = false){
		var list = this;
		if (returnNew) {
			return list.slice(0, list.length - 1);
		}
		if (list.length > 0) {
			list.splice( - 1, 1);
		}
		return list;
	},
	removeLastX: function(count, returnNew = false){
		var list = this;
		
		// if fewer items than wanted, clear entire array
		if (list.length < count) {
			if (returnNew) {
				return [];
			}
			list.length = 0;
			return list;
		}
		
		// delete X items from end
		if (returnNew) {
			return list.slice(0, list.length - count);
		}else{

			list.splice( -count, count);
			return list;
		}
	},
	
	removeEdges: function(fromLeftEdge, fromRightEdge){
		var list = this;
		if ((list.length - fromLeftEdge - fromRightEdge) <= 0) {
			return [];
		}
		return list.slice(fromLeftEdge, list.length - fromRightEdge);
	},
	
	
	splitAt: function(slot, includeSlot = false, includeInFirst = false){
		var list = this;
		if (includeSlot) {
			if (includeInFirst) {
				return [list.slice(0, slot + 1), list.slice(slot + 1)];
			}else {

				return [list.slice(0, slot), list.slice(slot)];
			}
		}
		return [list.slice(0, slot), list.slice(slot+1)];
	},
	splitAtEvery: function(val){
		var list = this;
		var splits = [];
		var lastSlot = 0;
		for (var a = 0, al = list.length;a<al;a++){
			if (list[a] == val && a > lastSlot) {
				splits.push(list.slice(lastSlot, a));
				lastSlot = a + 1;
			}
		}
		return splits;
	},
	
	moveToTop: function(slot, returnNew = false){
		var list = this;

		if (returnNew){

			// ALWAYS RETURNS NEW ARRAY
			
			// exit quickly if slot not in array
			var al = list.length;
			if (slot < 0 || slot >= al) {
				return list.concat();
			}
			
			// create new array with slot on top
			var newArr = [list[slot]];
			var n = 1;
			
			// add all other slots
			for (var a = 0;a<al;a++){
				if (a != slot) {
					newArr[n++] = list[a];
				}
			}

			return newArr;

		}else{


			// MODIFIES ARRAY IN PLACE
			
			// exit quickly if slot not in array
			var al = list.length;

			if (slot < 0 || slot >= al) {
				return;

			}
			
			// delete and re-add slot
			var val = list[slot];
			list.splice(slot, 1);
			list.unshift(val);

		}
	},
	moveToBottom: function(slot, returnNew = false){
		var list = this;

		if (returnNew){

			// ALWAYS RETURNS NEW ARRAY
			
			// exit quickly if slot not in array
			var al = list.length;
			if (slot < 0 || slot >= al) {
				return list.concat();
			}
			
			// create new array with slot on top
			var newArr = [];
			var n = 0;
			
			// add all other slots
			for (var a = 0;a<al;a++){
				if (a != slot) {
					newArr[n++] = list[a];
				}
			}
			
			// add slot to bottom
			newArr[n++] = list[slot];

			return newArr;

		}else{


			// MODIFIES ARRAY IN PLACE
			
			// exit quickly if slot not in array
			var al = list.length;

			if (slot < 0 || slot >= al) {
				return;

			}
			
			// delete and re-add slot
			var val = list[slot];
			list.splice(slot, 1);
			list.push(val);

		}
	},
	moveUp: function(item){
		var list = this;
		
		// MODIFIES ARRAY IN PLACE
		
		// exit quickly if slot not in array, or already on top
		var slot = list.indexOf(item);
		if (slot <= 0) {
			return false;
		}
		
		// move one up
		Swap(list, slot, slot - 1);
		return true;
	},
	moveDown: function(item){
		var list = this;
		
		// MODIFIES ARRAY IN PLACE
		
		// exit quickly if slot not in array, or already at bottom
		var al = list.length;
		var slot = list.indexOf(item);
		if (slot < 0 || slot >= (al - 1)) {
			return false;
		}
		
		// move one down
		Swap(list, slot, slot + 1);
		return true;
	},
	moveSlotUp: function(slot){
		var list = this;
		
		// MODIFIES ARRAY IN PLACE
		
		// exit quickly if slot not in array, or already on top
		var al = list.length;
		if (slot <= 0 || slot >= al) {
			return false;
		}
		
		// move one up
		Swap(list, slot, slot - 1);
		return true;
	},
	moveSlotDown: function(slot){
		var list = this;
		
		// MODIFIES ARRAY IN PLACE
		
		// exit quickly if slot not in array, or already at bottom
		var al = list.length;
		if (slot < 0 || slot >= (al - 1)) {
			return false;
		}
		
		// move one down
		Swap(list, slot, slot + 1);
		return true;
	},
	/** Move an item from the given list, to the start/end of the target list */
	moveToArray: function(item, toList, evenIfExists = false, addToEnd = true){
		var list = this;
		
		// remove from source list
		RemoveOne(list, item);
		
		// add to target list
		if (evenIfExists || toList.indexOf(item) === -1) {
			if (addToEnd) {
				toList.push(item);
			}else{
				toList.unshift(item);
			}
			return true;
		}
		
		return false;
	},

	
	contains: function(value){
		var list = this;
		if (list.length === 1) {
			return list[0] == value;
		}
		return list.indexOf(value) > -1;
	},
	containsAny: function(values){
		var list = this;
		return IndexOfAny(list, values) > -1;
	},
	containsAll: function(values){
		var list = this;
		
		// exit if either null
		if (list == null || values == null || list.length === 0 || values.length === 0) {

			return false;
		}
		
		// check if all found
		for (var f = 0, fl = values.length;f<fl;f++){
			if (list.indexOf(values[f]) === -1) {
				return false;
			}
		}
		return true;
	},
	

	indexOfArray: function(containsArr){
		var list = this;
		
		// returns index of containing list in main array
		
		if (list.length < containsArr.length) {
			return -1;
		}
		
		var cl = containsArr.length;
		for (var a = 0, al = list.length - (cl - 1);a<al;a++){
			
			var allMatch = true;
			for (var c = 0;c<cl;c++){
				if (list[a+c] != containsArr[c]) {
					allMatch = false;
					break;
				}
			}
			
			if (allMatch) {
				return a;
			}
		}
		return -1;
	},
	

	beginsWithArray: function(value){
		return this.startsWithArray(value);
	},
	startsWithArray: function(check){
		var list = this;
		
		// quickly test if length sufficient
		var clen = check.length;
		var mlen = list.length;
		if (mlen < clen) {
			return false;
		}
		
		// check if first slots match
		for (var b = 0;b<clen;b++){
			if (list[b] != check[b]) {
				return false;
			}
		}
		return true;
	},
	endsWithArray: function(check){

		var list = this;
		
		// quickly test if length sufficient
		var clen = check.length;
		var mlen = list.length;
		if (mlen < clen) {
			return false;
		}
		
		// check if last slots match
		var off = (mlen - clen);
		for (var b = 0;b<clen;b++){
			if (list[off + b] != check[b]) {
				return false;
			}
		}
		return true;
	},
	beginsWith: function(value){
		return this.startsWith(value);
	},
	startsWith: function(value){
		var list = this;
		return list[0] == value;
	},
	endsWith: function(value){
		var list = this;
		return list[list.length - 1] == value;
	},
	
	next: function(obj, wrap = false){

		var list = this;
		if (list == null) {

			return null;
		}
		var i = list.indexOf(obj);
		if (i > -1) {
			return (wrap && i >= (list.length - 1)) ? list[0] : list[i + 1];
		}
		return null;
	},
	prev: function(obj, wrap = false){
		var list = this;
		if (list == null) {

			return null;
		}
		var i = list.indexOf(obj);
		if (i > 0) {
			return wrap ? list[list.length - 1] : list[i - 1];
		}
		return null;
	},
	
	
	/** Returns the nearest existing slot value in the array. Returns `ifNoSlots` if the array is empty. */
	within: function(slot, ifNoSlots = null){
		var list = this;
		
		// return null if array empty
		var len = list.length;
		if (len === 0) {
			return ifNoSlots;
		}
		
		// return first slot if index negative
		if (slot < 0) {
			return list[0];
		}
		
		// return last slot if index more than last slot
		if (slot >= len) {
			return list[len - 1];
		}
		
		// return given slot if within array
		return list[slot];
	},
	
	first: function(list){
		var list = this;
		var len = list.length;
		if (len === 0) {
			return null;
		}
		return list[0];
	},
	firstExisting: function(slots, blankVal = null){
		var list = this;
		for (var s = 0, sl = slots.length;s<sl;s++){
			var val;
			if ((val = list[slots[s]]) != blankVal) {
				return val;
			}
		}
		return null;
	},
	last: function(list){
		var list = this;
		var len = list.length;
		if (len === 0) {
			return null;
		}
		return list[len-1];
	},
	lastX: function(count){
		var list = this;
		var s = (0).max(list.length - count);
		return list.slice(s, list.length);
	},
	setFirst: function(value){
		var list = this;
		var len = list.length;
		if (len === 0) {
			return;
		}
		list[0] = value;
	},
	setLast: function(value){
		var list = this;
		var len = list.length;
		if (len === 0) {
			return;
		}
		list[len-1] = value;
	},
	
	random: function(list){
		var list = this;
		
		// return null if array empty
		if (list.length === 0) {
			return null;
		}
		
		// return random slot within array
		return list[parseInt(Math.random() * 1000000) % list.length];
	},

	pick: function(IDs, sameSlots = false, fastAndUnsafe = false, out = null, evenIfNull = false){
		var list = this;
		if (out == null){

			out = [];
		}
		
		if (IDs){
			if (fastAndUnsafe) {
				
				for (var i = 0, il = IDs.length;i<il;i++){
					var id = IDs[i];
					var val = list[id];
					if (sameSlots) {
						out[id] = val;
					}else{
						out.push(val);
					}
				}
				
			}else{
				
				for (var i = 0, il = IDs.length;i<il;i++){

					id = IDs[i];
					if (id > -1){
						val = list[id];
						if (val != null || evenIfNull) {

							if (sameSlots) {
								out[id] = val;
							}else{
								out.push(val);
							}
						}
					}
				}
				
			}
		}
		
		return out;
	},

	/** Get the data of `list`, by searching `indexID` in `indexArr`, or return `defaultVal` if not found */
	getByMatchingArray: function(indexArr, indexID, defaultVal = null){
		var list = this;
		var slot = indexArr.indexOf(indexID);
		return slot === -1 ? defaultVal : list[slot];
	},
	/** Set the data of `list`, by searching `indexID` in `indexArr` */
	setByMatchingArray: function(indexArr, indexID, data){
		var list = this;
		var slot = indexArr.indexOf(indexID);
		if (slot === -1) {
			return false;
		}
		list[slot] = data;
		return true;
	},
	
	page: function(page, pageLength, invisibleRows = null){
		var list = this;
		
		// ensure page no. in limits
		var lastPage = Math.ceil(list.length / pageLength);
		page = page.limitTo(0, lastPage - 1);
		
		// get first/last row in page
		var pageStart = page*pageLength;/// 0-based - first row in page
		var pageEnd = (pageStart + pageLength) - 1;/// 0-based - last row in page
		
		// get on-page rows
		var visibleRows = list.getRange(pageStart, pageLength);
		
		// get off-page rows
		if (invisibleRows) {
			invisibleRows.addRange(list, 0, pageStart - 1);
			invisibleRows.addRange(list, pageEnd + 1, list.length - 1);
		}
		
		return visibleRows;
	},
	
	trim: function(returnNew = false, trimVal = null){
		var list = this;
		var first = IndexOf(list, trimVal, true);
		if (first === -1) {
			if (returnNew) {
				return [];
			}else {

				list.length = 0;
			}
		}else{
			var last = list.lastIndexOf(trimVal, true);
			if (returnNew) {
				return GetManySE(list, first, last);
			}else {

				
				if (first != -1 && first != 0){

					DeleteManySE(list, 0, first-1);
				}
				if (last != -1){
					list.length = last - first + 1; 
				}
			}
		}
		return list;
	},

	trimLeft: function(returnNew = false, trimVal = null){
		var list = this;
		var first = IndexOf(list, trimVal, true);
		if (first === -1) {
			if (returnNew) {
				return [];
			}else {

				list.length = 0;
			}
		}else{
			if (returnNew) {
				return GetAfter(list, first);
			}else {

				if (first != -1 && first != 0){

					DeleteManySE(list, 0, first-1);
				}
			}
		}
		return list;
	},
	trimRight: function(returnNew = false, trimVal = null){
		var list = this;
		var last = IndexOf(list, trimVal, true);
		if (last === -1) {
			if (returnNew) {
				return [];
			}else {

				list.length = 0;
			}
		}else{
			if (returnNew) {
				return GetBefore(list, last);
			}else {

				list.length = last + 1;
			}
		}
		return list;
	},
	
	transpose: function() {
		var arr = this;
		var transposed = [];
		
		for (var r = 0; r < arr.length; r++) {
			for (var c = 0; c < arr[r].length; c++) {
				if (transposed[c] == null) {

					transposed[c] = [];
				}
				transposed[c][r] = arr[r][c];
			}
		}
		
		return transposed;
	},
	
	none:null
};

// register funcs
UB.registerFuncs(Array.prototype, arrayFuncs);

1			/** global: UB */
2			/** global: Buffer */
3
4			/! ARRAY UTILS /
5
6			var arrayFuncs = {
7
8			merge: function(){
9			var arr = this;
10			var val1 = arr[0];
11
12			// if array of strings
13			if (val1.isString()){
14			return val1.join("");
15			}
16
17			// if array of arrays
18			if (val1.isArray()){
19			var merged = [];
20			for (var a = 0, al = arr.length; a<al; a++){
21			merged.addArray(arr[a]);
22			}
23			return merged;
24			}
25
26			// if array of Buffers
27			//removeIf(nodejs)
28			if (val1 instanceof Buffer){
29
30			// calc the total length of all buffers
31			var buffers = arr;
32			var len = 0;
33			for(var b = 0, bl = buffers.length; b < bl; b++) {
34			len += buffers[b].length;
35			}
36
37			// create a new buffer of that length
38			var mega = new Buffer(len);
39
40			// write all buffers into the mega buffer
nightfury7 / universalbasics.js

Push — master ( ad9a28...55041a )

arrayFuncs.moveDown A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
